package lib::SplitText;

use strict;
use warnings;
use lib::TextTreatment;


require Exporter;
our ($VERSION,@ISA,@EXPORT);

$VERSION = 0.01;

=head1 NAME

lib::SplitText - Bibliotheque de decoupage de texte

=head1 SYNOPSIS



=head1 DESCRIPTION

    Ce module permet de decouper un texte brute pour implementer les heuristiques de recherches

=head1 FUNCTIONS

=over 2

=cut

@ISA    = qw(Exporter);
@EXPORT = qw(
    &decoupe_par_mot &decoupe_par_phrase &decoupe_par_occurence &decoupe_par_chaine
);


=item decoupe_par_mot

 my $tabref = decoupe_par_mot("mon texte !", 9 , 50);

 Fonction retournant la reference d'un tableau de '50' chaines de carractere
 comportant caqune '9' mots pris aux hasard parmis lesmorceaux du texte decoupe en '50'
 le texte comportera apres uniquement des mots sans ponctuation.

=cut

# sub decoupe_par_mot($$$){
#     my($text, $nb_mots, $nb_req) = @_;
#     my @words = split(/\s+/, $text);
#     my $taille_parties;
#     if($nb_parties > 0){
#         $taille_parties = int(scalar(@words) /  $nb_parties );
#     }else{
#         warn '$nb_parties negatif ou nul (lib::SplitText::decoupe_par_mot)';
#         exit;
#     }
#     if($taille_parties < $nb_mots ){
#         $taille_parties = $nb_mots;
#     }
#     $nb_parties = int(scalar(@words) / $taille_parties);
#     my @tab;
#     for my $i (0..$nb_parties) {
#         my $fin = 0;
#         my $suite;
#         my $k = int(rand($taille_parties - $nb_mots));
#         my $l = $i*$taille_parties+$k;
#         for($l..$l+$nb_mots-1){
#             my $n = $_;
#             if($words[$n]){
#                 $suite .= " ".$words[$n];
#                 $fin++;
#             }
#         }
#         my @liste = ($l,$fin);
#         my %case;
#         $case{text} = $suite;
#         $case{offset} = \@liste;
#         $tab[$i] = \%case;
#     }
#     return \@tab;
# }


sub decoupe_par_chaine($$$){
    my($text, $len_str, $nb_req) = @_;
    my $lentext = length($text);
    $len_str = $lentext if $lentext < $len_str;
    my $len = $lentext - $len_str;

    my $len_part = int($len/$nb_req);
    if ($len_part < $len_str){
        $len_part = $len_str;
    }
    $nb_req = int($len/$len_part);
    $nb_req = 1 unless $nb_req;

    my @tab;
    my @part;
    for my $req (0..$nb_req-1){
        my $rand = int(rand($len_part - $len_str));
        $rand = 1 unless $rand; #cas ou rand=0;
        $rand += $req*$len_part;
#         push @part, substr($text, $rand, $len_str);
        my $phrase = substr($text, $rand, $len_str);
        my $len_phrase = length($phrase);
        $phrase =~ s/^.*?\s//m;
        $rand += $len_phrase-(length($phrase));  #position exacte.
        $phrase =~ s/\s\p{IsWord}+$//m;
        my $case = {
            text   => ucfirst(lc($phrase)),
            offset => $req,
            position => $rand,
        };
        push @tab, $case;
    }
    return \@tab;
}


=item decoupe_par_phrase

 my $tabref = decoupe_par_phrase("mon texte !", 15);

 Fonction retournant la reference d'un tableau de '15' chaines de carractere
 comportant chaqunes une suite de mot formant une phrase.
 le texte comportera apres uniquement des mots sans ponctuation.

=cut

sub decoupe_par_phrase{
    use lib::TextTreatment;
    my $text = shift;
    my $nb_phrases = shift;
    my @phrases = split(/[\.|!|\?|;]+/, $text);
    my $taille_parties;
    if($nb_phrases > 0){
        $taille_parties = int(scalar(@phrases)/$nb_phrases);
    }else{
        warn '$nb_phrases negatif ou nul (lib::SplitText::decoupe_par_phrase)';
        exit;
    }
    if($taille_parties < $nb_phrases ){
        $taille_parties = $nb_phrases;
    }
    $nb_phrases = int(scalar(@phrases) / $taille_parties);
    my @tab;
    my $nb_mots = 0;
    for (0..$nb_phrases) {
        my $i = $_;
        my $k = int(rand($taille_parties));
        my $l = $i*$taille_parties+$k;
        if($k>0){
            for($i*$taille_parties..$l-1){
                my @lis = split(/\s+/,set_noPunctuation($phrases[$_]));
                $nb_mots += int(scalar(@lis));
            }
        }
        my $phrase = set_noPunctuation($phrases[$l]);
        $phrase =~ s/\n/ /gm;
        my @liste = split(/\s+/,$phrase);
        my $fin = scalar(@liste);
        @liste = ($nb_mots,$fin);
        my %case =  {text => $phrase, offset => \@liste};
        $tab[$i] = \%case;
        for($l..($i+1)*$taille_parties-1){
            my @lis = split(/\s+/,set_noPunctuation($phrases[$_]));
            $nb_mots += int(scalar(@lis));
        }
    }
    return \@tab;
}


=item decoupe_par_occurence

 my $tabref = decoupe_par_occurence("mon texte !", 12);

 Fonction retournant la reference d'un tableau des '12' mots les plus frequents du texte
 Attention : il sera enleve tous les stopwords

=cut

sub decoupe_par_occurence{
    use lib::TextTreatment;
    use Lingua::StopWords qw( getStopWords );
    my $text = shift;
    my $nb_mots= shift;
    my $stopwords = getStopWords(get_language($text));
    $text = join ' ', grep { !$stopwords->{$_} } split /\s/, $text;
    my ($h, $occurence_sorted) = get_occurences(set_noPunctuation($text));
    my @tab;
    my @liste = (undef,undef);
    for(0..$nb_mots){
        my $mot = shift @$occurence_sorted;
        if( !(length($mot) <= 4) ){
            my @case =  ($mot,\@liste);
            push @tab , \@case;
        }else{
            $_--;
        }

    }
    return \@tab;
}

END { }
1;
__END__

=back

=head1 AUTEUR

    noplagia dev team

    http://noplagia.org

=cut
